{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:35.319937Z",
     "start_time": "2025-02-07T01:33:32.654813Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.6.0+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 加载数据",
   "id": "92a19dd204058cd"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:36.449522Z",
     "start_time": "2025-02-07T01:33:35.321115Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "id": "5b2bfa747663d0a0",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:39.999936Z",
     "start_time": "2025-02-07T01:33:36.450542Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:  # 遍历每张图片,img.shape=[1,28,28]\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])  # 这里的均值和标准差是通过train_ds计算得到的\n",
    ")\n"
   ],
   "id": "a53fcd4642407473",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 定义模型\n",
    "这里没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ],
   "id": "64bf59205d3cfa1f"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:40.012880Z",
     "start_time": "2025-02-07T01:33:40.000941Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 NeuralNetwork 的类，继承自 nn.Module\n",
    "# 继承 nn.Module 可以使用 PyTorch 提供的神经网络功能\n",
    "class NeuralNetwork(nn.Module):\n",
    "\n",
    "    # 定义类的构造函数，接受一个参数 layers_num，表示隐藏层的数量，默认值为 2。\n",
    "    # 初始化网络的层结构和参数\n",
    "    def __init__(self, layers_num=2):\n",
    "\n",
    "        # 调用父类的构造函数\n",
    "        # 确保 NeuralNetwork 类正确初始化\n",
    "        super().__init__()\n",
    "\n",
    "        # 将 transforms 赋值给类的属性 self.transforms\n",
    "        self.transforms = transforms\n",
    "\n",
    "        # 定义一个 Flatten 层，用于将输入数据展平为一维向量\n",
    "        self.flatten = nn.Flatten()\n",
    "\n",
    "        # 定义一个 Sequential 容器，包含一个全连接层和一个 ReLU 激活函数\n",
    "        # 构建网络的第一层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),\n",
    "            # 一般而言，先batch norm 后 激活函数\n",
    "            # 参见论文 《Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift》\n",
    "            nn.BatchNorm1d(100),  # num of features=100\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "\n",
    "        # 循环添加隐藏层，每层包括一个全连接层和一个 ReLU 激活函数\n",
    "        # 动态构建隐藏层，使网络深度可配置\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"batchnorm_{i}\", nn.BatchNorm1d(100))  #因为特征是1维的，所以用1维的batchnorm\n",
    "            self.linear_relu_stack.add_module(f\"relu\", nn.ReLU())\n",
    "\n",
    "        # 定义输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "\n",
    "        # 调用 init_weights 方法初始化网络参数\n",
    "        # 避免参数初始值不合适导致训练困难\n",
    "        self.init_weights()\n",
    "\n",
    "        # 定义 init_weights 方法，用于初始化网络参数\n",
    "        # self.modules(): 获取网络中的所有模块\n",
    "        # isinstance(m, nn.Linear): 检查模块是否为全连接层。\n",
    "        # nn.init.xavier_uniform_(m.weight): 使用 Xavier 初始化方法初始化权重。\n",
    "        # nn.init.zeros_(m.bias): 将偏置初始化为 0。\n",
    "        # 合适的参数初始化可以加速模型收敛\n",
    "\n",
    "    def init_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "        # 定义 forward 方法，实现网络的前向传播\n",
    "        # 输入数据经过 transforms 处理后，经过 flatten 层展平为一维向量\n",
    "        # 经过 linear_relu_stack 层，输出网络预测结果\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits\n",
    "\n",
    "\n",
    "# 计算并打印模型的参数数量和形状\n",
    "# NeuralNetwork(20).named_parameters(): 获取模型的所有参数及其名称。\n",
    "# np.prod(value.shape): 计算参数的个数（形状的乘积）。\n",
    "# total += np.prod(value.shape): 累加所有参数的数量。\n",
    "total = 0\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")\n",
    "    print(f\"Linear_{idx // 2:>02}\\tshape: {value.shape}\")\n",
    "    total += np.prod(value.shape)\n",
    "total"
   ],
   "id": "2bfa7060ce08fe71",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tshape: torch.Size([100, 784])\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_00\tshape: torch.Size([100])\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_01\tshape: torch.Size([100])\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_01\tshape: torch.Size([100])\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tshape: torch.Size([100, 100])\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_02\tshape: torch.Size([100])\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_03\tshape: torch.Size([100])\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_03\tshape: torch.Size([100])\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tshape: torch.Size([100, 100])\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_04\tshape: torch.Size([100])\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_05\tshape: torch.Size([100])\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_05\tshape: torch.Size([100])\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tshape: torch.Size([100, 100])\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_06\tshape: torch.Size([100])\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_07\tshape: torch.Size([100])\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_07\tshape: torch.Size([100])\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tshape: torch.Size([100, 100])\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_08\tshape: torch.Size([100])\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_09\tshape: torch.Size([100])\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_09\tshape: torch.Size([100])\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tshape: torch.Size([100, 100])\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_10\tshape: torch.Size([100])\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_11\tshape: torch.Size([100])\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_11\tshape: torch.Size([100])\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tshape: torch.Size([100, 100])\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_12\tshape: torch.Size([100])\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_13\tshape: torch.Size([100])\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_13\tshape: torch.Size([100])\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tshape: torch.Size([100, 100])\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_14\tshape: torch.Size([100])\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_15\tshape: torch.Size([100])\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_15\tshape: torch.Size([100])\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tshape: torch.Size([100, 100])\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_16\tshape: torch.Size([100])\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_17\tshape: torch.Size([100])\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_17\tshape: torch.Size([100])\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tshape: torch.Size([100, 100])\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_18\tshape: torch.Size([100])\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_19\tshape: torch.Size([100])\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_19\tshape: torch.Size([100])\n",
      "Linear_20\tparamerters num: 10000\n",
      "Linear_20\tshape: torch.Size([100, 100])\n",
      "Linear_20\tparamerters num: 100\n",
      "Linear_20\tshape: torch.Size([100])\n",
      "Linear_21\tparamerters num: 100\n",
      "Linear_21\tshape: torch.Size([100])\n",
      "Linear_21\tparamerters num: 100\n",
      "Linear_21\tshape: torch.Size([100])\n",
      "Linear_22\tparamerters num: 10000\n",
      "Linear_22\tshape: torch.Size([100, 100])\n",
      "Linear_22\tparamerters num: 100\n",
      "Linear_22\tshape: torch.Size([100])\n",
      "Linear_23\tparamerters num: 100\n",
      "Linear_23\tshape: torch.Size([100])\n",
      "Linear_23\tparamerters num: 100\n",
      "Linear_23\tshape: torch.Size([100])\n",
      "Linear_24\tparamerters num: 10000\n",
      "Linear_24\tshape: torch.Size([100, 100])\n",
      "Linear_24\tparamerters num: 100\n",
      "Linear_24\tshape: torch.Size([100])\n",
      "Linear_25\tparamerters num: 100\n",
      "Linear_25\tshape: torch.Size([100])\n",
      "Linear_25\tparamerters num: 100\n",
      "Linear_25\tshape: torch.Size([100])\n",
      "Linear_26\tparamerters num: 10000\n",
      "Linear_26\tshape: torch.Size([100, 100])\n",
      "Linear_26\tparamerters num: 100\n",
      "Linear_26\tshape: torch.Size([100])\n",
      "Linear_27\tparamerters num: 100\n",
      "Linear_27\tshape: torch.Size([100])\n",
      "Linear_27\tparamerters num: 100\n",
      "Linear_27\tshape: torch.Size([100])\n",
      "Linear_28\tparamerters num: 10000\n",
      "Linear_28\tshape: torch.Size([100, 100])\n",
      "Linear_28\tparamerters num: 100\n",
      "Linear_28\tshape: torch.Size([100])\n",
      "Linear_29\tparamerters num: 100\n",
      "Linear_29\tshape: torch.Size([100])\n",
      "Linear_29\tparamerters num: 100\n",
      "Linear_29\tshape: torch.Size([100])\n",
      "Linear_30\tparamerters num: 10000\n",
      "Linear_30\tshape: torch.Size([100, 100])\n",
      "Linear_30\tparamerters num: 100\n",
      "Linear_30\tshape: torch.Size([100])\n",
      "Linear_31\tparamerters num: 100\n",
      "Linear_31\tshape: torch.Size([100])\n",
      "Linear_31\tparamerters num: 100\n",
      "Linear_31\tshape: torch.Size([100])\n",
      "Linear_32\tparamerters num: 10000\n",
      "Linear_32\tshape: torch.Size([100, 100])\n",
      "Linear_32\tparamerters num: 100\n",
      "Linear_32\tshape: torch.Size([100])\n",
      "Linear_33\tparamerters num: 100\n",
      "Linear_33\tshape: torch.Size([100])\n",
      "Linear_33\tparamerters num: 100\n",
      "Linear_33\tshape: torch.Size([100])\n",
      "Linear_34\tparamerters num: 10000\n",
      "Linear_34\tshape: torch.Size([100, 100])\n",
      "Linear_34\tparamerters num: 100\n",
      "Linear_34\tshape: torch.Size([100])\n",
      "Linear_35\tparamerters num: 100\n",
      "Linear_35\tshape: torch.Size([100])\n",
      "Linear_35\tparamerters num: 100\n",
      "Linear_35\tshape: torch.Size([100])\n",
      "Linear_36\tparamerters num: 10000\n",
      "Linear_36\tshape: torch.Size([100, 100])\n",
      "Linear_36\tparamerters num: 100\n",
      "Linear_36\tshape: torch.Size([100])\n",
      "Linear_37\tparamerters num: 100\n",
      "Linear_37\tshape: torch.Size([100])\n",
      "Linear_37\tparamerters num: 100\n",
      "Linear_37\tshape: torch.Size([100])\n",
      "Linear_38\tparamerters num: 10000\n",
      "Linear_38\tshape: torch.Size([100, 100])\n",
      "Linear_38\tparamerters num: 100\n",
      "Linear_38\tshape: torch.Size([100])\n",
      "Linear_39\tparamerters num: 100\n",
      "Linear_39\tshape: torch.Size([100])\n",
      "Linear_39\tparamerters num: 100\n",
      "Linear_39\tshape: torch.Size([100])\n",
      "Linear_40\tparamerters num: 1000\n",
      "Linear_40\tshape: torch.Size([10, 100])\n",
      "Linear_40\tparamerters num: 10\n",
      "Linear_40\tshape: torch.Size([10])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "275410"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练",
   "id": "d911b185989182f4"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:40.044667Z",
     "start_time": "2025-02-07T01:33:40.013885Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "# 这是一个装饰器，用于禁用梯度计算。\n",
    "# 在评估模型时，我们不需要计算梯度，因为不会进行反向传播和参数更新。禁用梯度计算可以减少内存消耗并加速计算。\n",
    "@torch.no_grad()\n",
    "# 定义评估函数，接受三个参数：model（要评估的模型）、dataloader（数据加载器，用于提供评估数据）、loss_fct（损失函数）。\n",
    "# 用于评估模型在给定数据集上的性能。\n",
    "# 通过封装评估过程，可以方便地在不同模型和数据集上重复使用。\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    # 初始化三个空列表，分别用于存储每个批次的损失、预测标签和真实标签。\n",
    "    # 用于累积所有批次的损失和标签，以便后续计算平均损失和准确率。\n",
    "    # 累积所有批次的结果可以更准确地反映模型在整个数据集上的性能。\n",
    "    loss_list = []  # 记录损失\n",
    "    pred_list = []  # 记录预测\n",
    "    label_list = []  # 记录标签\n",
    "\n",
    "    # 遍历数据加载器中的每个批次，datas 是输入数据，labels 是对应的真实标签\n",
    "    for datas, labels in dataloader:\n",
    "        # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 将输入数据传递给模型，得到模型的输出 logits（通常是未归一化的预测分数）。\n",
    "        # 模型的前向传播过程，计算输入数据对应的输出。通过模型的输出可以计算损失和预测标签。\n",
    "        logits = model(datas)\n",
    "\n",
    "        # 将当前批次的损失值（转换为 Python 浮点数）添加到 loss_list 中。\n",
    "        # loss.item() 将张量中的单个值提取为 Python 浮点数。\n",
    "        # 累积所有批次的损失值，以便后续计算平均损失。\n",
    "        loss = loss_fct(logits, labels)\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 通过 argmax 函数获取模型预测的类别标签。axis=-1 表示在最后一个维度上取最大值对应的索引。\n",
    "        # logits 通常是每个类别的分数，argmax 找到分数最高的类别作为预测结果。\n",
    "        # 将模型的输出转换为具体的类别标签，便于与真实标签进行比较。\n",
    "        preds = logits.argmax(axis=-1)\n",
    "\n",
    "        # 将预测标签从 GPU 移动到 CPU，并转换为 NumPy 数组，再转换为 Python 列表，然后添加到 pred_list 中。\n",
    "        # preds.cpu().numpy().tolist() 将张量转换为 Python 列表。\n",
    "        # 累积所有批次的预测标签，以便后续计算准确率。\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    #计算预测标签和真实标签之间的准确率\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "\n",
    "    #返回所有批次的平均损失和准确率。\n",
    "    return np.mean(loss_list), acc"
   ],
   "id": "f61f638900a4b1f3",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### Tensorboard 可视化",
   "id": "bf15f06c65aecdc5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:42.056076Z",
     "start_time": "2025-02-07T01:33:40.045680Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir,\n",
    "                                    flush_secs=flush_secs)  # 实例化SummaryWriter, log_dir是log存放路径，flush_secs是每隔多少秒写入磁盘\n",
    "\n",
    "    def draw_model(self, model, input_shape):  #graphs\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))  # 画模型图\n",
    "\n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\",\n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "        )  # 画loss曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )  # 画acc曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "        )  # 画lr曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
    "\n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss,把loss，val_loss取掉，画loss曲线\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)  # 画loss曲线\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)  # 画acc曲线\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)  # 画lr曲线\n"
   ],
   "id": "8c2df3129dcef4b6",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 保存最好模型",
   "id": "e90b3a3c89900c08"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:42.061683Z",
     "start_time": "2025-02-07T01:33:42.057396Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 SaveCheckpointsCallback 的类。\n",
    "# 该类用于在训练过程中保存模型的检查点。封装保存检查点的逻辑，方便在训练过程中调用\n",
    "class SaveCheckpointsCallback:\n",
    "    \"\"\"\n",
    "    Callback to save model checkpoints during training.\n",
    "    \"\"\"\n",
    "\n",
    "    #定义类的构造函数，接受以下参数：\n",
    "    # save_dir: 检查点保存的目录。\n",
    "    # save_step: 每隔多少步保存一次检查点，默认值为 500。\n",
    "    # save_best_only: 是否只保存性能最好的检查点，默认值为 True\n",
    "    # 原理：初始化回调类的参数和状态\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "\n",
    "        # 初始化一个变量 best_metrics，用于记录当前最好的性能指标值，初始值为 -1\n",
    "        # 原理: 用于比较当前模型的性能是否优于之前保存的模型,当 save_best_only 为 True 时，只保存性能最好的模型\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # 检查保存目录是否存在，如果不存在则创建该目录\n",
    "        # os.path.exists()用于判断路径是否存在, os.mkdir()用于创建目录\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    # 定义 __call__ 方法，使类的实例可以像函数一样调用。参数包括：\n",
    "    # step: 当前训练的步数。\n",
    "    # state_dict: 模型的状态字典（包含模型参数）。\n",
    "    # metric: 当前模型的性能指标值（如验证集准确率），默认为 None\n",
    "    # 在训练过程中定期调用该方法，保存检查点\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "\n",
    "        # 检查当前步数是否是 save_step 的倍数，如果不是则直接返回\n",
    "        # 控制保存检查点的频率，避免频繁保存\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        # 检查是否只保存性能最好的检查点\n",
    "        # 根据 save_best_only 的值决定保存策略,提供两种保存策略：定期保存和只保存最佳模型\n",
    "        if self.save_best_only:\n",
    "\n",
    "            # 如果 save_best_only 为 True，则要求 metric 不能为 None。\n",
    "            # 原理: 使用 assert 断言确保 metric 有值。如果 metric 为 None，无法判断模型性能是否更好，因此需要提前检查\n",
    "            assert metric is not None\n",
    "\n",
    "            # 检查当前模型的性能指标是否优于之前保存的最佳模型\n",
    "            # 只保存性能更好的模型，避免保存性能下降的模型\n",
    "            if metric >= self.best_metrics:\n",
    "                # 将模型的状态字典保存到指定目录下的 best.ckpt 文件中\n",
    "                # 使用 torch.save 保存模型参数。保存当前性能最好的模型，方便后续加载和使用\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "\n",
    "                # 更新 best_metrics 为当前模型的性能指标值\n",
    "                self.best_metrics = metric\n",
    "\n",
    "        # 如果 save_best_only 为 False，则执行以下逻辑\n",
    "        # 定期保存检查点，不关心模型性能是否更好\n",
    "        else:\n",
    "\n",
    "            # 将模型的状态字典保存到指定目录下，文件名为当前步数\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))"
   ],
   "id": "a6f18fc340403b57",
   "outputs": [],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 早停",
   "id": "4720c83f1ce2c823"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:42.066689Z",
     "start_time": "2025-02-07T01:33:42.062687Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 EarlyStopCallback 的类.用于监控模型在验证集上的性能，并在性能不再提升时触发早停。\n",
    "# 封装早停的逻辑，方便在训练过程中调用\n",
    "class EarlyStopCallback:\n",
    "\n",
    "    # 定义类的构造函数，接受以下参数\n",
    "    # patience: 容忍的轮次数，默认值为 5。如果在 patience 轮内性能没有提升，则触发早停。\n",
    "    # min_delta: 性能提升的最小阈值，默认值为 0.01。只有当性能提升超过该阈值时，才认为模型有改进。\n",
    "    # 初始化早停回调的参数和状态\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "\n",
    "        # 将传入的参数保存为类的属性\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "\n",
    "        self.best_metric = -1  # 用于比较当前模型的性能是否优于之前的最佳性能\n",
    "\n",
    "        # 初始化一个计数器 counter，用于记录性能没有提升的连续轮次数，初始值为 0\n",
    "        # 当性能没有提升时，计数器增加；当性能提升时，计数器重置,用于判断是否达到了早停的条件\n",
    "        self.counter = 0\n",
    "\n",
    "    # 训练过程中定期调用该方法，更新早停状态\n",
    "    def __call__(self, metric):\n",
    "\n",
    "        # 检查当前性能指标是否比之前的最佳性能提升了至少 min_delta\n",
    "        # 避免微小的波动触发早停,当性能有显著提升时，才认为模型有改进\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "\n",
    "            self.best_metric = metric  # 记录当前最佳性能\n",
    "            self.counter = 0  # 性能有提升时，重置计数器,重新开始计算性能没有提升的连续轮次数\n",
    "\n",
    "        # 性能没有提升时，增加计数器\n",
    "        else:\n",
    "            self.counter += 1  # 记录性能没有提升的连续轮次数\n",
    "\n",
    "    # 定义一个只读属性 early_stop，用于判断是否触发早停。\n",
    "    # 使用 @property 装饰器将方法转换为属性。方便外部代码通过属性访问早停状态。\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "\n",
    "        # 检查计数器 counter 是否大于或等于 patience\n",
    "        # 提供早停的触发条件\n",
    "        return self.counter >= self.patience"
   ],
   "id": "4d832bdbea1d7eec",
   "outputs": [],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:33:42.073704Z",
     "start_time": "2025-02-07T01:33:42.067716Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 定义一个名为 training 的函数，用于训练模型。参数包括：\n",
    "# model: 要训练的模型。\n",
    "# train_loader: 训练数据的数据加载器。\n",
    "# val_loader: 验证数据的数据加载器。\n",
    "# epoch: 训练的轮数。\n",
    "# loss_fct: 损失函数。\n",
    "# optimizer: 优化器。\n",
    "# eval_step: 每隔多少步评估一次验证集性能，默认值为 500。\n",
    "# 该函数通过遍历训练数据，更新模型参数，并定期评估验证集性能。封装训练过程，方便重复使用\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        tensorboard_callback=None,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    # 初始化一个字典 record_dict，用于记录训练和验证过程中的损失和准确率。\n",
    "    # 通过记录训练和验证的性能，可以分析模型的训练过程。方便后续绘制训练曲线或分析模型表现。\n",
    "    record_dict = {\n",
    "        \"train\": [],  # \"train\": 存储训练集的损失和准确率。\n",
    "        \"val\": []  # \"val\": 存储验证集的损失和准确率。\n",
    "    }\n",
    "\n",
    "    # 初始化一个全局步数计数器 global_step，用于记录当前训练的步数。\n",
    "    # 步数用于控制何时评估验证集性能。通过步数而不是轮数来控制评估频率，更灵活。\n",
    "    global_step = 0\n",
    "\n",
    "    # 将模型设置为训练模式。在训练模式下，模型会启用一些特定于训练的功能（如 Dropout 和 BatchNorm）。\n",
    "    # 确保模型在训练时行为正确。\n",
    "    model.train()\n",
    "\n",
    "    # 使用 tqdm 创建一个进度条，总长度为 epoch * len(train_loader)，即总训练步数。\n",
    "    # tqdm 是一个进度条库，用于显示训练进度。\n",
    "    # 提供可视化的训练进度，方便监控训练过程。\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "\n",
    "        # 外层循环，遍历每个训练轮次。每个轮次会遍历整个训练数据集一次。\n",
    "        # 多轮训练可以提高模型的性能。\n",
    "        for epoch_id in range(epoch):\n",
    "\n",
    "            # 内层循环，遍历训练数据加载器中的每个批次。\n",
    "            for datas, labels in train_loader:\n",
    "\n",
    "                # 将输入数据和标签移动到指定的设备（GPU或CPU），转到GPU可以加速计算\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 清除优化器中之前的梯度。\n",
    "                # PyTorch 会累积梯度，因此在每次反向传播前需要清除之前的梯度。避免梯度累积导致错误的参数更新。\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                logits = model(datas)  # 模型前向计算\n",
    "                loss = loss_fct(logits, labels)  # 计算损失\n",
    "\n",
    "                # 计算损失相对于模型参数的梯度。\n",
    "                # 反向传播算法，通过链式法则计算梯度。梯度用于更新模型参数，以最小化损失。\n",
    "                loss.backward()\n",
    "\n",
    "                # 使用优化器更新模型参数。\n",
    "                optimizer.step()\n",
    "\n",
    "                preds = logits.argmax(axis=-1)  # 通过 argmax 函数获取模型预测的类别标签。\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())  # 计算当前批次的准确率\n",
    "                loss = loss.cpu().item()  # 将损失值从 GPU 移动到 CPU，并转换为 Python 浮点数。方便记录和打印损失值。\n",
    "\n",
    "                # 将当前批次的损失、准确率和步数记录到 record_dict[\"train\"] 中\n",
    "                # 累积训练过程中的性能指标。方便后续分析训练过程\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 每隔 eval_step 步评估一次验证集性能。\n",
    "                # 使用 global_step 控制评估频率。定期评估验证集性能，避免过拟合。\n",
    "                if global_step % eval_step == 0:\n",
    "                    # 将模型设置为评估模式\n",
    "                    model.eval()\n",
    "\n",
    "                    # 调用 evaluating 函数计算验证集的损失和准确率\n",
    "                    # 在验证集上评估模型性能。验证集性能反映了模型的泛化能力。\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "\n",
    "                    # 将验证集的损失、准确率和步数记录到 record_dict[\"val\"] 中。\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "\n",
    "                    # 将模型设置为训练模式\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        # 调用 tensorboard 回调函数，记录训练过程中的关键指标\n",
    "                        tensorboard_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于在 TensorBoard 中标识不同的训练阶段\n",
    "                            loss=loss, val_loss=val_loss,  # 记录训练集和验证集的损失值，用于监控模型在训练和验证集上的表现\n",
    "                            acc=acc, val_acc=val_acc,  # 记录训练集和验证集的准确率，用于监控模型的分类性能\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率，用于监控学习率的变化，确保学习率调整策略正常工作\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # 调用保存模型权重的回调函数，保存当前模型的权重\n",
    "                        save_ckpt_callback(\n",
    "                            global_step,  # 当前训练的全局步数，用于标识保存的模型权重对应的训练阶段\n",
    "                            model.state_dict(),  # 保存模型的当前状态字典（即模型的所有参数），以便后续可以恢复模型\n",
    "                            metric=val_acc  # 使用验证集的准确率作为指标，判断是否保存当前模型（通常只保存性能最好的模型）\n",
    "                        )\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 调用早停回调函数，监控验证集准确率是否不再提升\n",
    "                        early_stop_callback(val_acc)  # 传入验证集准确率，用于判断是否满足早停条件\n",
    "                        if early_stop_callback.early_stop:  # 检查是否触发了早停条件\n",
    "                            # 如果触发了早停条件，打印提示信息并结束训练\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 返回训练记录字典，包含训练过程中的关键指标\n",
    "\n",
    "                # 增加全局步数计数器\n",
    "                # 记录当前训练的步数,控制评估频率和记录训练进度\n",
    "                global_step += 1\n",
    "\n",
    "                # 更新进度条\n",
    "                pbar.update(1)\n",
    "\n",
    "                # 在进度条中显示当前训练的轮次。\n",
    "                # 更新进度条的后缀信息。方便监控训练进度。\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    # 返回记录的训练和验证性能的字典,包含训练和验证过程中的损失和准确率\n",
    "    return record_dict"
   ],
   "id": "a452d95c803a8a58",
   "outputs": [],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:56:13.119477Z",
     "start_time": "2025-02-07T01:56:13.035594Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 100\n",
    "\n",
    "# 实例化NeuralNetwork类，创建一个神经网络模型对象\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 定义了一个损失函数使用的是交叉熵损失函数，这是分类问题中常用的损失函数。\n",
    "# CrossEntropyLoss 结合了 Softmax 激活函数和 Log Loss，内部先做softmax，再计算交叉熵，用于多类别分类问题。\n",
    "# 输入是未经过 Softmax 处理的 logits（原始预测分数），而目标标签应该是类别的索引\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 优化器：用于更新模型的参数。\n",
    "# 这里使用的是 SGD（随机梯度下降，Stochastic Gradient Descent）优化算法。通过对每个数据点的梯度进行更新，快速地调整模型参数。\n",
    "# model.parameters()：这一部分是传入模型的所有参数，优化器将会基于这些参数计算梯度并进行更新。\n",
    "# lr：学习率，控制参数更新的步长。学习率越小，更新越慢；学习率越大，可能会导致训练不稳定。0.001 是一个比较常见的初始学习率。\n",
    "# momentum：动量是为了加速 SGD，避免在训练过程中振荡。动量值通常在 0 到 1 之间，0.9 是一个常用的选择。动量帮助优化器在上一次梯度的方向上继续前进，从而使得优化过程更为稳定。\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 实例化\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. 保存最佳模型\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/bn\", save_best_only=True)\n",
    "# 3. 早停\n",
    "early_stop_callback = EarlyStopCallback(patience=10)"
   ],
   "id": "55fd51912633ca11",
   "outputs": [],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:21:16.927444Z",
     "start_time": "2025-02-07T01:56:14.092550Z"
    }
   },
   "cell_type": "code",
   "source": [
    "record = training(\n",
    "    model,  # 要训练的模型\n",
    "    train_loader,  # 训练数据的数据加载器\n",
    "    val_loader,  # 验证数据的数据加载器\n",
    "    epoch,  # 训练的轮数\n",
    "    loss_fct,  # 损失函数\n",
    "    optimizer,  # 优化器\n",
    "    tensorboard_callback=None,  # tensorboard 可视化\n",
    "    save_ckpt_callback=save_ckpt_callback,  # 保存最佳模型\n",
    "    early_stop_callback=early_stop_callback,  # 早停\n",
    "    eval_step=len(train_loader)  # 每隔多少步评估一次验证集性能\n",
    ")"
   ],
   "id": "a715ad4ee2ef44c8",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "f485bf9423fa43638150189fa09e006d"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 17 / global_step 63750\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:21:17.072400Z",
     "start_time": "2025-02-07T02:21:16.928513Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "# 定义一个名为 plot_learning_curves 的函数，接受以下参数：\n",
    "# record_dict: 包含训练和验证记录的字典。\n",
    "# sample_step: 对训练数据进行采样的步长，默认值为 500。\n",
    "# 该函数用于可视化训练和验证过程中的性能指标。\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # 将训练记录转换为 Pandas DataFrame，并设置 step 列为索引。然后对数据进行采样，步长为 sample_step\n",
    "    # pd.DataFrame(record_dict[\"train\"]): 将训练记录转换为 DataFrame。\n",
    "    # .set_index(\"step\"): 将 step 列设置为索引。\n",
    "    # .iloc[::sample_step]: 对数据进行采样，每隔 sample_step 步取一个样本。\n",
    "    # 减少数据点的数量，使曲线更清晰，同时保留趋势\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "\n",
    "    # 将验证记录转换为 Pandas DataFrame，并设置 step 列为索引\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # 计算训练 DataFrame 的列数，即需要绘制的性能指标数量\n",
    "    # 确定需要创建的子图数量\n",
    "    fig_num = len(train_df.columns)\n",
    "\n",
    "    # 创建一个包含 fig_num 个子图的图形\n",
    "    # 为每个性能指标创建一个子图，方便对比\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "\n",
    "    # 遍历训练 DataFrame 的每一列（即每个性能指标）。\n",
    "    # 使用 enumerate 获取列名和索引\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index: x 轴数据（训练步数）。\n",
    "        # train_df[item]: y 轴数据（性能指标值）。\n",
    "        # label=f\"train_{item}\": 设置曲线的标签。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "\n",
    "        axs[idx].grid()  # 在当前子图上添加网格线\n",
    "        axs[idx].legend()  # 在当前子图上添加图例\n",
    "\n",
    "        # 生成 x 轴的刻度数据，从 0 到最大步数，步长为 5000\n",
    "        x_data = range(0, train_df.index[-1], 5000)\n",
    "\n",
    "        axs[idx].set_xticks(x_data)  # 设置 x 轴的刻度位置\n",
    "\n",
    "        # 设置 x 轴的刻度标签，将步数转换为“k”格式（如 5000 → \"5k\"）\n",
    "        # map(lambda x: f\"{int(x / 1000)}k\", x_data): 将刻度数据转换为“k”格式。\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x / 1000)}k\", x_data))\n",
    "\n",
    "        axs[idx].set_xlabel(\"step\")  # 设置 x 轴的标签为“step”\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=500)"
   ],
   "id": "a74c32989540c34",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T02:21:18.607233Z",
     "start_time": "2025-02-07T02:21:17.072400Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "model = model.to(device)\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/bn/best.ckpt\", weights_only=True, map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "c20bcbde0c67ab40",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.3374\n",
      "accuracy: 0.8830\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-07T01:50:04.867751Z",
     "start_time": "2025-02-07T01:50:04.867751Z"
    }
   },
   "cell_type": "code",
   "source": "",
   "id": "f25df9499f643b80",
   "outputs": [],
   "execution_count": null
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
